package com.atguigu.day18.lambda04.l1;

import org.junit.Test;

import javax.sound.midi.Soundbank;

/*
函数式接口:SAM接口  single  abstract method
            只有一个自定义的抽象方法
     注意:
         可以使用 @FunctionalInterface 判断是否为函数式接口
函数式接口的分类:
    1.消费型接口   没有返回值有形参       貔貅
    2.供给型接口   没有形参有返回值       舔狗
    3.判断型接口   有形参返回值是布尔类型  法官
    4.功能型接口    有形参也有返回值      普通人
Lambda表达式:
     作用: 简化函数式接口生成的匿名内部类
     基本语法: ()->{}
          ():重写方法的形参
          ->:lambda语法标识
          {}:重写方法的方法体
     基本语法的简化:
           1.重写的方法体只有一条语句 可以省略 {};
           2.可以省略形参的数据类型
           3.如果只有一个形参 可以省略 ()
           4.如果方法体只有一条返回语句 则可以省略{}; return
 */
public class LambdaTest {

    @Test
    public void test() {
        /*G g = (int a, int b) -> {
            return a * b;
        };*/
        G g = (a, b) -> a * b;
        int num = g.num(3, 6);
        System.out.println(num);
    }

    @Test
    public void test06() {
        //匿名内部类
       /* F f = new F() {
            @Override
            public String concat(String a, double b, int c) {
                return a+"-"+b+"-"+c;
            }
        };*/
        //lambda
        /*F f = (String a,double b,int c)->{
            return a+b+c;
        };*/
        F f = (a, b, c) -> a + b + c;

        String concat = f.concat("杨幂", 3.14, 666);
        System.out.println("concat = " + concat);
    }


    @Test
    public void test05() {
        //匿名内部类
     /*   E e = new E() {
            @Override
            public void sum(int a, int b) {
                System.out.println(a+b);
            }
        };*/
        //lambda
        /*E e = (int a, int b) -> {
            return a + b;
        };*/
        E e = (a, b) -> a + b;
        int sum = e.sum(33, 66);
        System.out.println("sum = " + sum);
    }

    @Test
    public void test04() {
        //匿名内部类
   /*     D d = new D() {
            @Override
            public void show(int num) {
                System.out.println("num = " + num);
            }
        };*/

        //lambda
        /*D d = (int num) -> {
            System.out.println(num);
        };*/
        D d = num -> System.out.println(num);

        d.show(999);
    }


    @Test
    public void test03() {
        //todo lambda
        /*Fly f = () -> {
            System.out.println("飞机飞....");
        };*/
        Fly f = () -> System.out.println("东风飞");
        f.flying();
    }

    @Test
    public void test02() {
        //todo 匿名内部类
        Fly f = new Fly() {
            @Override
            public void flying() {
                System.out.println("超人飞.....");
            }
        };
        f.flying();
    }

    @Test
    public void test01() {
        Bird bird = new Bird();
        bird.flying();
    }
}
